perm filename PIXSAI.SAI[VIS,HPM]14 blob
sn#390263 filedate 1978-10-25 generic text, type T, neo UTF8
entry pixdim,pfldim,getpfl,getpfd,putpfl,campix,CLPADJ,makpix;
entry normalize, synchronize,diminterest,interest;
begin
REQUIRE "FILHDR.SAI[VIS,HPM]" SOURCE_FILE;
DEFINE PCLN=0; comment index of word in a picture file containing
number of scanlines in the picture;
DEFINE PCWD=1; comment number of words in the picture;
DEFINE PCBY=2; comment number of valid bytes in the picture;
DEFINE PCBYA=3; comment no. of bytes including the nulls at the end of lines;
DEFINE LNWD=4; comment no. of words per scanline;
DEFINE LNBY=5; comment no. of valid bytes per scanline;
DEFINE LNBYA=6; comment no. of bytes per scanline, including the nulls;
DEFINE WDBY=7; comment no. of bytes per word;
DEFINE WDBI=8; comment no. of bits containing data in a word;
DEFINE BYBI=9; comment no. of bits per byte;
DEFINE BMAX=10; comment largest value of a byte;
DEFINE BPTAB=11; comment address of second entry in byte pntr. table;
DEFINE LINTAB=12; comment actual address of the first entry in the row table;
EXTERNAL PROCEDURE MAKTAB(REFERENCE INTEGER PICTURE);
EXTERNAL INTEGER PROCEDURE INTOP(REFERENCE INTEGER PICTURE;
INTEGER WINSIZ;
REFERENCE INTEGER RESULTARRY;
INTEGER YEDGE(0),XEDGE(0));
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARRY, PICTR);
EXTERNAL PROCEDURE PERBIT(REFERENCE INTEGER PICTURE, PERMUTATION);
EXTERNAL PROCEDURE HISTOG(REFERENCE INTEGER PICTURE, HISTOGRAM);
EXTERNAL PROCEDURE ROWSUM(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL PROCEDURE ROWSUD(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL INTEGER PROCEDURE CMPPAR(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE CLEAN(REFERENCE INTEGER PICTURE);
EXTERNAL PROCEDURE PASSHI(REFERENCE INTEGER PICTURE1;
INTEGER WINSIZ;
REFERENCE INTEGER PICTURE2);
EXTERNAL PROCEDURE HAFPIC(REFERENCE INTEGER PICTURE1,PICTURE2; INTEGER MAXBIT);
EXTERNAL INTEGER PROCEDURE MATCH(REFERENCE INTEGER PIC1,SY1,SX1,SY2,SX2;
REFERENCE INTEGER PIC2,DY1,DX1,DY2,DX2);
EXTERNAL PROCEDURE UNPACK(REFERENCE INTEGER SOURCEARRAY, PICTURE);
EXTERNAL PROCEDURE SELECT(REFERENCE INTEGER PICT1; INTEGER YEDGE,XEDGE;
REFERENCE INTEGER PICT2);
internal INTEGER PROCEDURE PFLDIM(STRING FILNAM);
comment returns the size of the picture FILNAM on disk.
used for allocating arrays in preparation for
actually reading them. Returns 0 on failure.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER ARRAY BUF[0:'177];
PRSFIL(FILNAM);
XXEOF←TRUE;
OPEN(10,DEVPRS,'10,19,0,XXCOUNT,XXBRCHAR,XXEOF);
IF ¬XXEOF THEN LOOKUP(10,FILPRS,XXFLAG);
IF XXFLAG ∨ XXEOF THEN
BEGIN
RELEASE(10);
RETURN(0);
END
ELSE
BEGIN
ARRYIN(10,BUF[0],'200); RELEASE(10);
IF BUF[0]=-1 THEN
BEGIN
XBYBI←BUF[1];
XLNBY←BUF[6]-BUF[5]+1;
XPCLN←BUF[4]-BUF[3]+1;
XLNWD←BUF[2];
XLNBYA←XLNWD*(36%XBYBI);
XPCWD←XLNWD*XPCLN;
RETURN(13+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN
XBYBI←BUF[2];
XLNBY←BUF[8]-BUF[7]+1;
XPCLN←BUF[6]-BUF[5]+1;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN RETURN(0)
ELSE RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
INTERNAL INTEGER PROCEDURE GETPFP(STRING FILNAM; REFERENCE INTEGER PICTURE;
INTEGER Y1,X1,COMY,COMX);
comment read and compress a portion of picture in file FILNAM into PICTURE.
upper left corner of area FILNAM transferred is
[y1,x1]. pixel squares of size COMY by COMX are
summed into each pixel of PICTURE
Returns picture size of success, 0 on failure.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L,FW,LW,FB,BPT,II,J,K;
INTEGER ARRAY BUF[0:'177];
PRSFIL(FILNAM);
XXEOF←TRUE;
OPEN(10,DEVPRS,'10,19,0,XXCOUNT,XXBRCHAR,XXEOF);
IF ¬XXEOF THEN LOOKUP(10,FILPRS,XXFLAG);
IF XXFLAG ∨ XXEOF THEN
BEGIN
RELEASE(10);
RETURN(0);
END
ELSE
BEGIN
INTEGER K,KK;
ARRYIN(10,BUF[0],10);
IF BUF[0]=-1 THEN
BEGIN
ARRYIN(10,BUF[10],'200-10);
KK←'200;
comment in case file is MIT pseudo stanford format, and has no pointers;
FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN KK←BUF[K];
L←LOCATION(PICTURE);
XBYBI←BUF[1];
XLNBY←BUF[6]-BUF[5]+1;
XPCLN←BUF[4]-BUF[3]+1;
XWDBY←36%XBYBI;
XLNWD←BUF[2];
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
XXPICLOC←(KK LAND '777777);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
XBYBI←BUF[2];
XLNBY←BUF[8]-BUF[7]+1;
XPCLN←BUF[6]-BUF[5]+1;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
RELEASE(10);
RETURN(0);
END;
XXPICLOC←10;
END;
FB←X1 MOD XWDBY;
FW←X1 % XWDBY;
LW←(X1+MEMORY[L+LNBY]*COMX-1) % XWDBY;
BEGIN
INTEGER ARRAY BF[0:LW-FW], PIXL[0:MEMORY[L+LNBY]-1];
INTEGER SCAN,SCAD;
PROCEDURE POSN(INTEGER WRD);
BEGIN
INTEGER I; INTEGER ARRAY BU[0:WRD MOD 128];
WRD←WRD+XXPICLOC;
USETI(10,WRD%128+1);
ARRYIN(10,BU[0],WRD MOD 128);
END;
SCAN←MEMORY[L+BMAX]+1; SCAD←(COMX*COMY*2↑XBYBI);
FOR I←0 STEP 1 UNTIL MEMORY[L+PCLN]-1 DO
BEGIN
POSN((I*COMY+Y1)*XLNWD+FW); ARRYIN(10,BF[0],LW-FW+1);
BPT←POINT(XBYBI,BF[0],FB*XBYBI-1);
FOR K←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
BEGIN
PIXL[K]←ILDB(BPT);
FOR KK←2 STEP 1 UNTIL COMX DO PIXL[K]←PIXL[K]+ILDB(BPT);
END;
FOR II←2 STEP 1 UNTIL COMY DO
BEGIN
INTEGER BPT;
POSN((I*COMY+Y1+II-1)*XLNWD+FW); ARRYIN(10,BF[0],LW-FW+1);
BPT←POINT(XBYBI,BF[0],FB*XBYBI-1);
FOR K←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
FOR KK←1 STEP 1 UNTIL COMX DO PIXL[K]←PIXL[K]+ILDB(BPT);
END;
FOR J←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
BEGIN
EXTERNAL PROCEDURE PUTEL(REFERENCE INTEGER PIX; INTEGER I,J,VALUE);
PUTEL(MEMORY[L],I,J,(PIXL[J]*SCAN)%SCAD);
END;
END;
END;
END;
END;
internal INTEGER PROCEDURE GETPFD(STRING FILNAM; REFERENCE INTEGER PICTURE);
comment read the header of file FILNAM into area of core whose first
word is PICTURE. Used to get parameters of a picture on disk.
Returns picture size on success, 0 on failure.
Decimal 11 words are returned, PICTURE must be at least this big;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
INTEGER ARRAY BUF[0:'177];
PRSFIL(FILNAM);
XXEOF←TRUE;
OPEN(10,DEVPRS,'10,19,0,XXCOUNT,XXBRCHAR,XXEOF);
IF ¬XXEOF THEN LOOKUP(10,FILPRS,XXFLAG);
IF XXFLAG ∨ XXEOF THEN
BEGIN
RELEASE(10);
RETURN(0);
END
ELSE
BEGIN
ARRYIN(10,BUF[0],10);
IF BUF[0]=-1 THEN
BEGIN
ARRYIN(10,BUF[10],'200-10);
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[1];
MEMORY[L+LNBY]←XLNBY←BUF[6]-BUF[5]+1;
MEMORY[L+PCLN]←XPCLN←BUF[4]-BUF[3]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←BUF[2];
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
RELEASE(10);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[2];
MEMORY[L+LNBY]←XLNBY←BUF[8]-BUF[7]+1;
MEMORY[L+PCLN]←XPCLN←BUF[6]-BUF[5]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
RELEASE(10);
RETURN(0);
END;
RELEASE(10);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
internal INTEGER PROCEDURE GETPFL(STRING FILNAM; REFERENCE INTEGER PICTURE);
comment read the picture in FILNAM into area of core whose first
word is PICTURE. PFLDIM(FILNAM) words are needed.
Returns picture size on success, 0 on failure;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
INTEGER ARRAY BUF[0:'177];
PRSFIL(FILNAM);
XXEOF←TRUE;
OPEN(10,DEVPRS,'10,19,0,XXCOUNT,XXBRCHAR,XXEOF);
IF ¬XXEOF THEN LOOKUP(10,FILPRS,XXFLAG);
IF XXFLAG ∨ XXEOF THEN
BEGIN
RELEASE(10);
RETURN(0);
END
ELSE
BEGIN
INTEGER K,KK;
ARRYIN(10,BUF[0],10);
IF BUF[0]=-1 THEN
BEGIN
ARRYIN(10,BUF[10],'200-10);
KK←'200;
comment for MIT pseudo stanford format, which has no pointers;
FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN KK←BUF[K];
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[1];
MEMORY[L+LNBY]←XLNBY←BUF[6]-BUF[5]+1;
MEMORY[L+PCLN]←XPCLN←BUF[4]-BUF[3]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←BUF[2];
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCHN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
MEMORY[L+BPTAB]←13+XPCLN+L;
MAKTAB(PICTURE);
XXPICLOC←(KK LAND '777777) - '200;
IF XXPICLOC<0 THEN BEGIN USETI(10,1); XXPICLOC←XXPICLOC+'200; END;
FOR I←1 STEP 1 UNTIL XXPICLOC DO WORDIN(10);
ARRYIN(10,MEMORY[L+13+XPCLN+XLNBYA],XPCWD);
RELEASE(10);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[2];
MEMORY[L+LNBY]←XLNBY←BUF[8]-BUF[7]+1;
MEMORY[L+PCLN]←XPCLN←BUF[6]-BUF[5]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
MEMORY[L+BPTAB]←13+XPCLN+L;
MAKTAB(PICTURE);
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
RELEASE(10);
RETURN(0);
END;
ARRYIN(10,MEMORY[L+13+XPCLN+XLNBYA],XPCWD);
RELEASE(10);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
internal INTEGER PROCEDURE PIXDIM(INTEGER HEIGHT,WIDTH,BITS);
comment returns the size of the array needed to hold a hypothetical
picture HEIGHT scanlines by WIDTH pixels per scanline
by BITS bits per pixel.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER L;
XBYBI←BITS;
XLNBY←WIDTH;
XPCLN←HEIGHT;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE MAKPIX(INTEGER HEIGHT,WIDTH,BITS; REFERENCE INTEGER PICTURE);
comment actually creates an empty picture HEIGHT by WIDTH by BITS in
the area of core beginning with PICTURE. Returns its size.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BITS;
MEMORY[L+LNBY]←XLNBY←WIDTH;
MEMORY[L+PCLN]←XPCLN←HEIGHT;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
MEMORY[L+BPTAB]←13+XPCLN+L;
MAKTAB(PICTURE);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE PUTPFL(REFERENCE INTEGER PICTURE; STRING FILNAM);
comment write out the picture in the core area starting with
PICTURE, creating a file called FILNAM. Returns
the size of the original file on success, else 0.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
INTEGER ARRAY BUF[0:'177];
PRSFIL(FILNAM);
XXEOF←TRUE;
OPEN(10,DEVPRS,'10,0,19,XXCOUNT,XXBRCHAR,XXEOF);
IF ¬XXEOF THEN ENTER(10,FILPRS,XXFLAG);
IF XXFLAG ∨ XXEOF THEN
BEGIN
RELEASE(10);
RETURN(0);
END
ELSE
BEGIN
L←LOCATION(PICTURE);
BUF[0]←-1;
BUF[1]←XBYBI←MEMORY[L+BYBI];
BUF[2]←XLNWD←MEMORY[L+LNWD];
BUF[3]←1; BUF[4]←XPCLN←MEMORY[L+PCLN];
BUF[5]←1; BUF[6]←XLNBY←MEMORY[L+LNBY];
BUF[7]←((-(XPCWD←MEMORY[L+PCWD])) LSH 18) LOR '200;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
ARRYOUT(10,BUF[0],'200);
ARRYOUT(10,MEMORY[L+13+XPCLN+XLNBYA],XPCWD);
RELEASE(10);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
internal INTEGER PROCEDURE diminterest(REFERENCE INTEGER PICTURE; INTEGER IW);
BEGIN
INTEGER HIG,WID,BITS;
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
RETURN(PIXDIM((HIG-1)%IW,(WID-1)%IW,10));
END;
internal PROCEDURE INTEREST(REFERENCE INTEGER PICTURE; INTEGER IW;
REFERENCE INTEGER RESULT);
BEGIN
INTEGER HIG,WID,BITS,IAV,I,J,IWW,BYMAX;
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARY, PICT);
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
BEGIN
INTEGER ARRAY INTER[-2:(HIG-1)%IW-1,0:(WID-1)%IW-1];
IAV←INTOP(PICTURE,IW,INTER[0,0]);
IWW←IW*IW;
BYMAX←2↑BITS-1;
FOR I←(HIG-1)%IW-1 STEP -1 UNTIL 0 DO
FOR J←(WID-1)%IW-1 STEP -1 UNTIL 0 DO
INTER[I,J]←8*SQRT(INTER[I,J]/IWW) MIN BYMAX;
MAKPIX((HIG-1)%IW,(WID-1)%IW,BITS,RESULT);
GETPAR(INTER[0,0],RESULT);
END;
END;
INTERNAL PROCEDURE ENHANCE(REFERENCE INTEGER PIC);
BEGIN
INTEGER INTEG,I,TOT,BITS,SAMPS;
BITS←MEMORY[LOCATION(PIC)+BYBI];
SAMPS←2↑BITS;
BEGIN
INTEGER ARRAY GREYS[0:SAMPS-1];
HISTOG(PIC,GREYS[0]);
TOT←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO TOT←TOT+GREYS[I];
INTEG←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO
BEGIN
INTEG←INTEG+GREYS[I];
GREYS[I]←(SAMPS-1)*INTEG/TOT;
END;
PERBIT(PIC,GREYS[0]);
END;
END;
INTERNAL PROCEDURE SYNCHRONIZE(REFERENCE INTEGER PIC);
BEGIN
INTEGER I,J,K,WINPOS,HIG;
REAL WINVAL,TRIALVAL;
HIG←MEMORY[LOCATION(PIC)+PCLN];
BEGIN
INTEGER ARRAY ROWSM[0:HIG-1];
DEFINE DK=".6";
ROWSUD(PIC,ROWSM[0]);
WINPOS←HIG-1;
WINVAL←ROWSM[HIG-1];
FOR I←0 STEP 1 UNTIL HIG-1 DO WINVAL←WINVAL*DK + ROWSM[I]*(1-DK);
TRIALVAL←WINVAL;
FOR J←0 STEP 1 UNTIL HIG-1 DO
BEGIN
TRIALVAL←TRIALVAL*DK + ROWSM[J]*(1-DK);
IF TRIALVAL≤WINVAL THEN
BEGIN
WINVAL←TRIALVAL;
WINPOS←J;
END;
END;
IF WINPOS<HIG-1 THEN
BEGIN
INTEGER BODY,BODYSIZ;
INTEGER ARRAY COPY[0:BODYSIZ←MEMORY[LOCATION(PIC)+PCWD]];
BODY←MEMORY[LOCATION(PIC)+LINTAB];
WINPOS←(WINPOS+1)*MEMORY[LOCATION(PIC)+LNWD];
ARRBLT(COPY[0],MEMORY[BODY+WINPOS],BODYSIZ-WINPOS);
ARRBLT(COPY[BODYSIZ-WINPOS],MEMORY[BODY],WINPOS);
ARRBLT(MEMORY[BODY],COPY[0],BODYSIZ);
END;
END;
END;
INTERNAL INTEGER PROCEDURE CAMPIX(INTEGER CAMRA,YEDGE,XEDGE;
REFERENCE INTEGER PICTURE;
INTEGER SUMS(1),BCLIP(7),TCLIP(0),NTRY(10));
comment read a picture from camera CAMRA of size defined by array PICTURE
the area of core beginning with PICTURE. Upper left hand
corner is at PICX,PICY. SUMS and CLPINC are averaging params.;
BEGIN
EXTERNAL INTEGER PROCEDURE TVSNAP(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL INTEGER PROCEDURE TVRAW(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL PROCEDURE WIPE(REFERENCE INTEGER PICTURE; INTEGER VALUE);
EXTERNAL PROCEDURE TVBTMX(REFERENCE INTEGER PIC4,PICN,XFRM; INTEGER TOPV(7));
EXTERNAL PROCEDURE PICADD(REFERENCE INTEGER PICTURE,PICSUM);
EXTERNAL PROCEDURE SHRINK(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE PICSH(REFERENCE INTEGER PIC1,PIC2; INTEGER DIV);
INTEGER XPCLN,XLNBY,XBYBI;
INTEGER L,CAM,DW,ERS,I,J,K,NDEL;
PRELOAD_WITH '12,'13,'11,'10,'15,'14,'16,'17,'5,'4,'6,'7,'2,'3,'1,'0;
OWN INTEGER ARRAY GREY[0:15];
IF CAMRA>'40 THEN CAMRA←CAMRA LAND '67;
IF CAMRA='42∨CAMRA='41 THEN CAM←CAMRA LAND 3 ELSE
BEGIN
INTEGER I,J;
I←'401400000000 LOR LOCATION(J);
J←IF CAMRA≥'40 THEN CAMRA LAND 7 ELSE 1 LSH (35-CAMRA);
START_CODE
MOVE 1,I;
CALLI 1,'400070; COMMENT VDSMAP;
JUMP 0,0;
END;
CAM←3;
END;
L←LOCATION(PICTURE);
XPCLN←MEMORY[L+PCLN];
XLNBY←MEMORY[L+LNBY];
XBYBI←MEMORY[L+BYBI];
NDEL←0; SUMS←SUMS MAX 1;
BEGIN
INTEGER ARRAY T1[0:IF XBYBI≠4 THEN PIXDIM(XPCLN,XLNBY,4) ELSE 0],
T[0:IF SUMS>1 THEN PIXDIM(XPCLN,XLNBY,12) ELSE 0];
IF XBYBI≠4 THEN MAKPIX(XPCLN,XLNBY,4,T1[0]);
IF SUMS>1 THEN
BEGIN
MAKPIX(XPCLN,XLNBY,12,T[0]);
WIPE(T[0],0);
END;
ERS←0;
FOR K←1 STEP 1 UNTIL SUMS DO
BEGIN
IF XBYBI>4 THEN
BEGIN
INTEGER CLPINC,TC,BC,CLPSTP;
INTEGER MXBY;
MXBY←2↑XBYBI-1;
CLPINC←(BCLIP-TCLIP+1)*15/MXBY;
CLPINC←((CLPINC MAX 1) MIN 7);
CLPSTP←CLPINC%2 MAX 1;
WIPE(PICTURE,-1);
TC←TCLIP;
DO
BEGIN
INTEGER ARRAY XFRM[0:15];
REAL TM,BM;
BC←TC+CLPINC-1;
TM←(BCLIP+1-TC)*MXBY/(BCLIP-TCLIP+1);
BM←(BCLIP-BC)*MXBY/(BCLIP-TCLIP+1);
FOR I←0 STEP 1 UNTIL 15 DO
XFRM[I]←
((2*GREY[I]*(TM-BM)+TM+29*BM)/30 MAX 0) MIN MXBY;
DW←TVRAW(CAM,YEDGE,XEDGE,T1[0],BC,TC,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
TVBTMX(T1[0],PICTURE,XFRM[0],7);
TC←TC+CLPSTP;
END;
END
UNTIL BC≥BCLIP∨DW<0;
ERS←ERS+DW;
END
ELSE
IF XBYBI=4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,PICTURE,BCLIP,TCLIP,NDEL←NDEL+NTRY)
ELSE
IF XBYBI<4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,T1[0],BCLIP,TCLIP,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
IF SUMS>1 THEN PICADD(PICTURE,T[0]);
ERS←ERS+DW;
END
ELSE
BEGIN
K←SUMS;
ERS←-1;
END;
END;
IF ERS≥0 THEN
IF SUMS>1 THEN PICSH(T[0],PICTURE,SUMS) ELSE
IF XBYBI<4 THEN SHRINK(T1[0],PICTURE);
END;
RETURN(ERS);
END;
INTERNAL INTEGER PROCEDURE CLPADJ(INTEGER CAMRA;
REFERENCE INTEGER BCLIP,TCLIP;
REAL LIMB(.01),LIMT(.01));
BEGIN
INTEGER ARRAY T[0:PIXDIM(200,200,4)];
INTEGER NRT;
MAKPIX(200,200,4,T[0]);
NRT←CAMPIX(CAMRA,20,20,T[0],1,7,0,10);
IF NRT≥0 THEN
BEGIN
INTEGER ARRAY A[0:15],TT,TB[0:7]; INTEGER I,S,P;
HISTOG(T[0],A[0]);
S←0; FOR I←0 STEP 1 UNTIL 7 DO S←S+(TB[I]←TT[I]←A[15-2*I]+A[14-2*I]);
LIMB←LIMB*S; LIMT←LIMT*S;
FOR I←1 STEP 1 UNTIL 7 DO TT[I]←TT[I]+TT[I-1];
FOR I←6 STEP -1 UNTIL 0 DO TB[I]←TB[I]+TB[I+1];
TCLIP←0; BCLIP←7;
FOR I←0 STEP 1 UNTIL 7 DO IF ABS(TT[I]-LIMT)<ABS(TT[TCLIP]-LIMT) THEN TCLIP←I;
FOR I←7 STEP -1 UNTIL TCLIP DO IF ABS(TB[I]-LIMB)<ABS(TB[BCLIP]-LIMB)
THEN BCLIP←I;
END;
RETURN(NRT);
END;
end